All 7 copied filterlist tiers crashed every replicate with a non-zero exit,
while all 8 pre-existing cases in the same job passed 10/10. Uniform failure
across tiers ruled out filterlist size; the differences from the comparable
working case (quality_gate_metrics_logs) were the target resources and the
offered load, neither of which had ever been validated in a real SMP job.

Drop 20k-100k and bring 10k in line with quality_gate_metrics_logs:

  cpu_allotment      6        -> 4
  memory_allotment   8192 MiB -> 2GiB
  offered load       60 MiB/s -> 20 MiB/s (18/1/1, 90/5/5 split preserved)

The 8192 MiB allotment was never measured; it had been raised
1024 -> 2048 -> 4096 -> 8192 reactively in response to these same crashes.
Bounds are now ceilings below the allotment rather than equal to it, so
memory_usage can actually fail; tighten both once a run reports a peak.

Verified the traffic still exercises the filter list: all 676 guaranteed-match
names are in the 10k list, no guaranteed-nomatch name is, patterns are
character ranges so lading cannot rewrite the padding.

Test allocated when the submitted name needed rewriting, because Normalize
has to return a string. That is not a rare path in practice: lading's
DogStatsD generator draws names from letters and digits only, and 10 of
those 62 characters are digits, so ~16% of generated names do not start
with a letter and are therefore not normalized. Measured over lading-shaped
names that came to 34 B/op amortised, ~630 KB/s of garbage at the 18 MiB/s
the paired SMP case offers, which is the likeliest source of the small
memory delta that case reported.

Split the parser out as normalizeAppend so Test can build the normalized
form in a stack buffer. A normalized name is never longer than its input and
firstAlpha rejects anything over MaxLength, so append never reallocates and
the buffer does not escape.

Measured on lading-shaped names against a 10k list, same seed and matcher:

                       before                after
  mixed traffic        566 ns  34 B/op       512 ns  0 B/op
  normalized only      -                     503 ns  0 B/op
  needs rewrite        -                     566 ns  0 B/op

Roughly 10% faster on the mix rather than slower: two allocations cost more
than zeroing a 350-byte stack buffer. The fast path is unchanged, and the
mix matches 0.84*503 + 0.16*566 = 513 as expected.

…iting

quality_gate_metric_filterlist_10k barely exercises the normalisation rewrite
path. Its background generator is 90% of the traffic and uses lading's random
names, whose alphabet is letters and digits only; a normalised name must start
with a letter, and 10 of those 62 characters are digits, so only ~16% of names
need rewriting.

Add quality_gate_metric_filterlist_10k_rewrite, identical to the base case in
every other respect (10k entries, 3 generators at 18/1/1 MiB/s, 4 CPU, 2GiB),
where every name carries '-' characters and so must be rewritten. The filter
list holds the normalised spelling, so this also fails loudly if normalisation
is ever removed from Matcher.Test: nothing would be filtered.

Read this case for CPU, not memory. All three generators need explicit
metric_names pools because lading's random alphabet cannot emit '-', so
background contributes 13520 distinct names instead of the base case's
contexts: 1000..10000, which moves the aggregator's context count for reasons
unrelated to what is being measured. Noted in the case README.

Also restructure the Go path benchmarks as BenchmarkMatcherTestPaths, holding
probe count, name length and list shape constant across variants. The previous
set was confounded: differing fixture sizes and layout made an unrelated cache
effect look like a code-path difference, reporting the rewrite path as 4x
FASTER than the fast path. With shape held constant:

  already-normalized   146-170 ns/op   0 allocs
  hyphenated           180-199 ns/op   0 allocs   <- the new SMP case's shape
  leading-digit        187-195 ns/op   0 allocs
  trailing-hyphen      251-259 ns/op   0 allocs   <- pathological for the check

Each variant asserts its own premise before measuring, which is what caught a
fixture bug here: '-' normalises to '_', not '.', so the entries have to be the
underscore spelling.